package com.qdd.freight.entity;

import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.http.HttpStatus;

import java.util.HashMap;

/**
 * 返回结果实体类
 *
 * @ClassName Result
 * @Description TODO
 * @Author peijie
 * @Date 2019/12/12 22:27
 * @Version 1.0
 **/
@Data
@EqualsAndHashCode(callSuper = false)
public class Result extends HashMap<String, Object> {
    /**
     * 状态码
     */
    public static final String STATUS = "status";

    /**
     * 返回内容
     */
    public static final String MESSAGE = "message";

    /**
     * 数据对象
     */
    public static final String DATA = "data";

    /**
     * 加密lock值
     */
    public static final String LOCK = "lock";


    /**
     * 初始化一个新创建的 Result 对象
     *
     * @param type 状态类型
     * @param msg  返回内容
     * @param data 数据对象
     */
    public Result(Type type, String msg, Object data) {
        super.put(STATUS, type.value);
        super.put(MESSAGE, msg);
        if (null != data) {
            super.put(DATA, data);
        }
    }

    /**
     * 初始化一个新创建的 Result 对象（无data类型）
     *
     * @param type 状态类型
     * @param msg  返回内容
     */
    public Result(Type type, String msg) {
        super.put(STATUS, type.value);
        super.put(MESSAGE, msg);
    }

    /**
     * 自定义方法调用 Result对象
     */
    public Result(Integer type, String msg, Object data) {
        super.put(STATUS, type);
        super.put(MESSAGE, msg);
        if (null != data) {
            super.put(DATA, data);
        }
    }

    /**
     * 自定义方法调用 Result对象
     */
    public Result(Integer type, String msg) {
        super.put(STATUS, type);
        super.put(MESSAGE, msg);
    }


    /**
     * 接口成功回调方法调用 Result对象
     */
    public Result(Integer type, String msg, String data, String lock) {
        super.put(STATUS, type);
        super.put(MESSAGE, msg);
        if (null != data) {
            super.put(DATA, data);
        }
        super.put(LOCK, lock);
    }

    /**
     * 状态类型
     */
    public enum Type {
        /**
         * 成功  200
         */
        SUCCESS(HttpStatus.OK.value()),
        /**
         * 参数错误 400
         */
        BAD_REQUEST(HttpStatus.BAD_REQUEST.value()),
        /**
         * 服务器错误 500
         */
        ERROR(HttpStatus.INTERNAL_SERVER_ERROR.value());
        private final int value;

        Type(int value) {
            this.value = value;
        }

        public int value() {
            return this.value;
        }
    }

    /**
     * 返回成功消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result success(String msg, Object data) {
        return new Result(Type.SUCCESS, msg, data);
    }

    /**
     * 返回成功消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result success(Object data) {
        return new Result(Type.SUCCESS, "请求成功", data);
    }

    /**
     * 返回成功消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result success(Type type, String msg, Object data) {
        return new Result(type, msg, data);
    }

    /**
     * 无data类型
     *
     * @param type
     * @param msg
     * @return
     */

    public static Result successNoData(Type type, String msg) {
        return new Result(type, msg);
    }

    public static Result successNoData() {
        return new Result(Type.SUCCESS, "请求成功");
    }

    public static Result successNoData(String msg) {
        return new Result(Type.SUCCESS, msg);
    }


    /**
     * 返回失败消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result error(String msg, Object data) {
        return new Result(Type.ERROR, msg, data);
    }

    /**
     * 返回失败消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result error(Object data) {
        return new Result(Type.ERROR, "服务器异常", data);
    }

    /**
     * 返回失败消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result error(Type type, String msg, Object data) {
        return new Result(type, msg, data);
    }

    /**
     * 无data类型
     *
     * @param type
     * @param msg
     * @return
     */
    public static Result errorNoData(Type type, String msg) {
        return new Result(type, msg);
    }

    public static Result errorNoData() {
        return new Result(Type.ERROR, "服务器异常");
    }

    public static Result errorNoData(String msg) {
        return new Result(Type.ERROR, msg);
    }


    /**
     * 返回请求错误消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result badRequest(String msg, Object data) {
        return new Result(Type.BAD_REQUEST, msg, data);
    }

    /**
     * 返回请求错误消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result badRequest(Object data) {
        return new Result(Type.BAD_REQUEST, "请求错误", data);
    }

    /**
     * 返回请求错误消息
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result badRequest(Type type, String msg, Object data) {
        return new Result(type, msg, data);
    }

    /**
     * 无data类型
     *
     * @param type
     * @param msg
     * @return
     */
    public static Result badRequestNoData(Type type, String msg) {
        return new Result(type, msg);
    }

    public static Result badRequestNoData() {
        return new Result(Type.BAD_REQUEST, "请求错误");
    }

    public static Result badRequestNoData(String msg) {
        return new Result(Type.BAD_REQUEST, msg);
    }

    /**
     * 自定义返回类型
     *
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result customMsg(Integer type, String msg, Object data) {
        return new Result(type, msg, data);
    }

    /**
     * 无data类型
     */
    public static Result customMsgNoData(Integer type, String msg) {
        return new Result(type, msg);
    }

    /**
     * 加密接口成功返回接口
     *
     * @return
     */
    public static Result interfaceSuccess(String data, String lock) {
        return new Result(Type.SUCCESS.value, "请求成功", data, lock);
    }
}
